Analyzing Business Relations & Documents

class: title-slide

# ER018 - Analyzing Business Relations & Documents

## PVA1

### Arbeiten mit Zeichenketten (strings)

<br>
<br>
<br>
<br>
<br>
<br>
<br>
### FS 2024
<br>
### Prof. Dr. Jörg Schoder
.mycontacts[
<svg aria-hidden="true" role="img" viewBox="0 0 496 512" style="height:1em;width:0.97em;vertical-align:-0.125em;margin-left:auto;margin-right:auto;font-size:inherit;fill:currentColor;overflow:visible;position:relative;"><path d="M165.9 397.4c0 2-2.3 3.6-5.2 3.6-3.3.3-5.6-1.3-5.6-3.6 0-2 2.3-3.6 5.2-3.6 3-.3 5.6 1.3 5.6 3.6zm-31.1-4.5c-.7 2 1.3 4.3 4.3 4.9 2.6 1 5.6 0 6.2-2s-1.3-4.3-4.3-5.2c-2.6-.7-5.5.3-6.2 2.3zm44.2-1.7c-2.9.7-4.9 2.6-4.6 4.9.3 2 2.9 3.3 5.9 2.6 2.9-.7 4.9-2.6 4.6-4.6-.3-1.9-3-3.2-5.9-2.9zM244.8 8C106.1 8 0 113.3 0 252c0 110.9 69.8 205.8 169.5 239.2 12.8 2.3 17.3-5.6 17.3-12.1 0-6.2-.3-40.4-.3-61.4 0 0-70 15-84.7-29.8 0 0-11.4-29.1-27.8-36.6 0 0-22.9-15.7 1.6-15.4 0 0 24.9 2 38.6 25.8 21.9 38.6 58.6 27.5 72.9 20.9 2.3-16 8.8-27.1 16-33.7-55.9-6.2-112.3-14.3-112.3-110.5 0-27.5 7.6-41.3 23.6-58.9-2.6-6.5-11.1-33.3 2.6-67.9 20.9-6.5 69 27 69 27 20-5.6 41.5-8.5 62.8-8.5s42.8 2.9 62.8 8.5c0 0 48.1-33.6 69-27 13.7 34.7 5.2 61.4 2.6 67.9 16 17.7 25.8 31.5 25.8 58.9 0 96.5-58.9 104.2-114.8 110.5 9.2 7.9 17 22.9 17 46.4 0 33.7-.3 75.4-.3 83.6 0 6.5 4.6 14.4 17.3 12.1C428.2 457.8 496 362.9 496 252 496 113.3 383.5 8 244.8 8zM97.2 352.9c-1.3 1-1 3.3.7 5.2 1.6 1.6 3.9 2.3 5.2 1 1.3-1 1-3.3-.7-5.2-1.6-1.6-3.9-2.3-5.2-1zm-10.8-8.1c-.7 1.3.3 2.9 2.3 3.9 1.6 1 3.6.7 4.3-.7.7-1.3-.3-2.9-2.3-3.9-2-.6-3.6-.3-4.3.7zm32.4 35.6c-1.6 1.3-1 4.3 1.3 6.2 2.3 2.3 5.2 2.6 6.5 1 1.3-1.3.7-4.3-1.3-6.2-2.2-2.3-5.2-2.6-6.5-1zm-11.4-14.7c-1.6 1-1.6 3.6 0 5.9 1.6 2.3 4.3 3.3 5.6 2.3 1.6-1.3 1.6-3.9 0-6.2-1.4-2.3-4-3.3-5.6-2z"/></svg> @FFHS-EconomicResearch
<svg aria-hidden="true" role="img" viewBox="0 0 448 512" style="height:1em;width:0.88em;vertical-align:-0.125em;margin-left:auto;margin-right:auto;font-size:inherit;fill:currentColor;overflow:visible;position:relative;"><path d="M416 32H31.9C14.3 32 0 46.5 0 64.3v383.4C0 465.5 14.3 480 31.9 480H416c17.6 0 32-14.5 32-32.3V64.3c0-17.8-14.4-32.3-32-32.3zM135.4 416H69V202.2h66.5V416zm-33.2-243c-21.3 0-38.5-17.3-38.5-38.5S80.9 96 102.2 96c21.2 0 38.5 17.3 38.5 38.5 0 21.3-17.2 38.5-38.5 38.5zm282.1 243h-66.4V312c0-24.8-.5-56.7-34.5-56.7-34.6 0-39.9 27-39.9 54.9V416h-66.4V202.2h63.7v29.2h.9c8.9-16.8 30.6-34.5 62.9-34.5 67.2 0 79.7 44.3 79.7 101.9V416z"/></svg> @jfschoder
]

---
layout: true

<div style="position: absolute;left:400px;bottom:10px;font-size:9px"><svg aria-hidden="true" role="img" viewBox="0 0 496 512" style="height:1em;width:0.97em;vertical-align:-0.125em;margin-left:auto;margin-right:auto;font-size:inherit;fill:currentColor;overflow:visible;position:relative;"><path d="M245.83 214.87l-33.22 17.28c-9.43-19.58-25.24-19.93-27.46-19.93-22.13 0-33.22 14.61-33.22 43.84 0 23.57 9.21 43.84 33.22 43.84 14.47 0 24.65-7.09 30.57-21.26l30.55 15.5c-6.17 11.51-25.69 38.98-65.1 38.98-22.6 0-73.96-10.32-73.96-77.05 0-58.69 43-77.06 72.63-77.06 30.72-.01 52.7 11.95 65.99 35.86zm143.05 0l-32.78 17.28c-9.5-19.77-25.72-19.93-27.9-19.93-22.14 0-33.22 14.61-33.22 43.84 0 23.55 9.23 43.84 33.22 43.84 14.45 0 24.65-7.09 30.54-21.26l31 15.5c-2.1 3.75-21.39 38.98-65.09 38.98-22.69 0-73.96-9.87-73.96-77.05 0-58.67 42.97-77.06 72.63-77.06 30.71-.01 52.58 11.95 65.56 35.86zM247.56 8.05C104.74 8.05 0 123.11 0 256.05c0 138.49 113.6 248 247.56 248 129.93 0 248.44-100.87 248.44-248 0-137.87-106.62-248-248.44-248zm.87 450.81c-112.54 0-203.7-93.04-203.7-202.81 0-105.42 85.43-203.27 203.72-203.27 112.53 0 202.82 89.46 202.82 203.26-.01 121.69-99.68 202.82-202.84 202.82z"/></svg>Prof. Dr. Jörg Schoder</div>

---
name: agenda
class: left

.blockquote[Agenda]

## Arbeiten mit Zeichenketten (strings)

* (Sehr kurze) Einführung in R-Objekte

* Zeichenketten in Base-R und das stringr-Paket

* Regelhafte Ausdrücke (regular expressions)

* Fortgeschrittene reguläre Ausdrücke

---
class: left

.blockquote[Intro R-Objekte]

## R als objektorientierte Sprache

* Objekte lassen sich in Klassen einteilen
  * tibbles, data.frames
  * Vektoren
  * Funktionen

--
* Objekte sind vektorbasiert

--
* Variablentypen

--
  * logisch (`logical`)

--
  * numerisch
      * `integer`
      * `double`
--
  * kategorial
      * `character` (Zeichenketten, engl. strings)
      * `factor`

???

* logical: binäre Logik (true vs. false)
* numerisch: integer (ganze Zahlen), double (Doppelgleitkommazahlen)
* kategoriale Daten
  * strings (Zeichenketten)
  * factors für überschaubar viele Ausprägungen, die nich alphanumerisch geordnet werden sollen

---
class: inverse, center, middle

## Zeichenketten in Base-R und das stringr-Paket

.blockquote[strings erzeugen]

.blockquote[strings verknüpfen]

.blockquote[strings zerlegen]

---
class: left

.blockquote[strings erzeugen]

## Eingabe mit Anführungzeichen

* Einfache Anführungszeichen

```r
"hoi!"
```

```
## [1] "hoi!"
```

* Doppelte Anführungszeichen

```r
'hoi!'
```

```
## [1] "hoi!"
```

* Problem: verschachtelte Anführungszeichen

```r
# Ich habe "hoi!" gesagt
"Ich habe "hoi!" gesagt."
```

```
## Error: <text>:2:12: unerwartetes Symbol
## 1: # Ich habe "hoi!" gesagt
## 2: "Ich habe "hoi
##               ^
```

---
class: left

.blockquote[strings erzeugen]

## Escape-Sequenz

* Verschachtelte Anführungszeichen: 
  * Variante 1 (`'`)

```r
'Ich habe "hoi!" gesagt.'
```

```
## [1] "Ich habe \"hoi!\" gesagt."
```
  
  * Variante 2 `\"` (Escape Sequenz!)

```r
"Ich habe \"hoi!\" gesagt."
```

```
## [1] "Ich habe \"hoi!\" gesagt."
```

---
class: left

.blockquote[strings erzeugen]

## Weitere Anwendungsfälle für Escape Sequenzen

* Neue Zeile: `\n`

```r
"Mit dem Pfeil, dem Bogen
Durch Gebirg und Tal
Kommt der Schütz gezogen
Früh am Morgenstrahl."
```

```
## [1] "Mit dem Pfeil, dem Bogen\nDurch Gebirg und Tal\nKommt der Schütz gezogen\nFrüh am Morgenstrahl."
```
* Unicode-Symbole ([Unicode-Chart](https://www.unicode.org/charts/)):
  * 8 Hexcode-Symbole: `\U`
  * 8 Hexcode-Symbole: `\u`

???

Escape sequences
You might have been surprised at the output from the last part of the last exercise. How did you get two lines from one string, and how did you get that little globe? The key is the \.

A sequence in a string that starts with a \ is called an escape sequence and allows us to include special characters in our strings. You saw one escape sequence in the first exercise: \" is used to denote a double quote.

In "hello\n\U1F30D" there are two escape sequences: \n gives a newline, and \U followed by up to 8 hex digits sequence denotes a particular Unicode character.

Unicode is a standard for representing characters that might not be on your keyboard. Each available character has a Unicode code point: a number that uniquely identifies it. These code points are generally written in hex notation, that is, using base 16 and the digits 0-9 and A-F. You can find the code point for a particular character by looking up a code chart. If you only need four digits for the codepoint, an alternative escape sequence is \u.

When R comes across a `\` it assumes you are starting an escape, so if you actually need a backslash in your string you'll need the sequence `\\`.

---
class: left

## Zahlenformate

.pull-left[

```r
x <- pi
x
```

```
## [1] 3.141593
```
* `format()`: fix vs. wissenschaftlich

```r
format(x, scientific = TRUE)
```

```
## [1] "3.141593e+00"
```
* `as.character()`

```r
as.character(x)
```

```
## [1] "3.14159265358979"
```

???

wissenschaftlich: `$3,1415*10^0$`

---
class: left

.blockquote[strings verknüpfen]

## `paste()`-Funktion

```r
paste("H","O","P","P")
```

```
## [1] "H O P P"
```

```r
paste("H","O","P","P", sep = "-")
```

```
## [1] "H-O-P-P"
```

```r
paste(c("Hey","Ach","Mach"), "Du")
```

```
## [1] "Hey Du"  "Ach Du"  "Mach Du"
```
---
class: left

.blockquote[strings verknüpfen]

## Old MacDonald

```r
old_mac <- function(animal, animal_goes){
eieio <- paste("E", "I", "E", "I", "O", sep = "-")
old_mac <- "Old MacDonald had a farm"
writeLines(c(
old_mac,
eieio,
paste("And on his farm he had a", animal),
eieio,
paste(c("Here", "There", "Everywhere"), "a",
c(animal_goes, animal_goes,
paste(rep(animal_goes, 2), collapse = "-")),
collapse = ", "),
old_mac,
eieio))
}
```

---
class: left

.blockquote[strings verknüpfen]

## Old MacDonald

```r
old_mac("cow","moo")
```

```
## Old MacDonald had a farm
## E-I-E-I-O
## And on his farm he had a cow
## E-I-E-I-O
## Here a moo, There a moo, Everywhere a moo-moo
## Old MacDonald had a farm
## E-I-E-I-O
```

```r
old_mac("dog","wolf")
```

```
## Old MacDonald had a farm
## E-I-E-I-O
## And on his farm he had a dog
## E-I-E-I-O
## Here a wolf, There a wolf, Everywhere a wolf-wolf
## Old MacDonald had a farm
## E-I-E-I-O
```
---
class: left

.blockquote[strings zerlegen]

## stringr-Paket

* Leistungsstark, aber leicht zu erlernen

* Aufbauend auf stringi

* Prägnant und konsistent

* Alle Funktionen beginnen mit `str_`

* Alle Funktionen nehmen einen Vektor von Strings als erstes Argument

---
class: left

.blockquote[strings zerlegen]

## stringr-Vignette

---
class: inverse, center, middle

## Regelhafte Ausdrücke

.blockquote[Regelhafte Ausdrücke mit dem rebus-Paket]

.blockquote[Abwechselnde Zeichenfolgen (Alternations)]

.blockquote[Zeichenklassen (Character classes)]

.blockquote[Wiederholungen]

.blockquote[Abkürzungen]

---
class: left

.blockquote[Regelhafte Ausdrücke mit dem rebus-Paket]

## Regelhafte Ausdrücke

???

* regular expressions (regexp)

---
class: left

.blockquote[Regelhafte Ausdrücke mit dem rebus-Paket]

## Regelhafte Ausdrücke

* Übersicht

| Muster               | Regelmäßiger Ausdruck |   rebus    |
|----------------------|:---------------------:|:----------:|
| Beginn eines strings |          `^`          |  `START`   |
| Ende eines strings   |          `$`          |   `END`    |
| Einzelne Symbole     |          `.`          | `ANY_CHAR` |
| "Belegte" Symbole (`.`,`^`,`$`)|    `\.`,`\^`,`\$` | `DOT`,`CARAT`, `DOLLAR`|

* Besondere Muster regelhafte Ausdrücke
  * Alternative Zeichenfolgen (Alternations)
  * Zeichenklassen (character classes)
  * Wiederholungen

---
class: left

.blockquote[Alternative Zeichenfolgen]

## Unterschiedliche Kombinationen von Zeichenfolgen

`(winter|sommer)`

```r
library(stringr)
library(rebus)
or("Winter","Sommer")
```

```
## <regex> (?:Winter|Sommer)
```

```r
str_view(c("Sommer-Hitze","Traum-Winter","Traumwinter"),
  pattern = or("[Ww]inter","[Ss]ommer"),
  match=TRUE,html=TRUE)
```

<div class="str_view html-widget html-fill-item-overflow-hidden html-fill-item" id="htmlwidget-1fb08be37bd7a587240b" style="width:960px;height:100%;"></div>
<script type="application/json" data-for="htmlwidget-1fb08be37bd7a587240b">{"x":{"html":"<ul>\n  <li><pre><span class='match'>Sommer<\/span>-Hitze<\/pre><\/li>\n  <li><pre>Traum-<span class='match'>Winter<\/span><\/pre><\/li>\n  <li><pre>Traum<span class='match'>winter<\/span><\/pre><\/li>\n<\/ul>"},"evals":[],"jsHooks":[]}</script>
???

* Obs! Die erste Ausgabe unterscheidet sich leicht von der Eingabe: rebus ergänzt um `?:`, um anzuzeigen, dass es sich um eine "nicht-einfangende Gruppe" von Zeichen (non-capturing group) handelt. Dazu später mehr

---
class: left

.blockquote[Zeichenklassen (character classes)]

## Identifikation von (definierten) Symbolen

.pull-left[

```r
char_class("Aa")
```

```
## <regex> [Aa]
```

```r
str_view(c("Frankfurt","Freiheit","Effekt","Schifffahrt"),
          pattern = char_class("Ff"),html=TRUE
)
```

<div class="str_view html-widget html-fill-item-overflow-hidden html-fill-item" id="htmlwidget-52fe23b8c31b30d34867" style="width:960px;height:100%;"></div>
<script type="application/json" data-for="htmlwidget-52fe23b8c31b30d34867">{"x":{"html":"<ul>\n  <li><pre><span class='match'>F<\/span>rank<span class='match'>f<\/span>urt<\/pre><\/li>\n  <li><pre><span class='match'>F<\/span>reiheit<\/pre><\/li>\n  <li><pre>E<span class='match'>f<\/span><span class='match'>f<\/span>ekt<\/pre><\/li>\n  <li><pre>Schi<span class='match'>f<\/span><span class='match'>f<\/span><span class='match'>f<\/span>ahrt<\/pre><\/li>\n<\/ul>"},"evals":[],"jsHooks":[]}</script>
]
--
.pull-right[

```r
negated_char_class("Ff")
```

```
## <regex> [^Ff]
```

```r
str_view(c("Frankfurt","Freiheit","Effekt","Schifffahrt"),
          pattern = negated_char_class("Ff"),html=TRUE
)
```

<div class="str_view html-widget html-fill-item-overflow-hidden html-fill-item" id="htmlwidget-666ad033f93aa79d16c9" style="width:960px;height:100%;"></div>
<script type="application/json" data-for="htmlwidget-666ad033f93aa79d16c9">{"x":{"html":"<ul>\n  <li><pre>F<span class='match'>r<\/span><span class='match'>a<\/span><span class='match'>n<\/span><span class='match'>k<\/span>f<span class='match'>u<\/span><span class='match'>r<\/span><span class='match'>t<\/span><\/pre><\/li>\n  <li><pre>F<span class='match'>r<\/span><span class='match'>e<\/span><span class='match'>i<\/span><span class='match'>h<\/span><span class='match'>e<\/span><span class='match'>i<\/span><span class='match'>t<\/span><\/pre><\/li>\n  <li><pre><span class='match'>E<\/span>ff<span class='match'>e<\/span><span class='match'>k<\/span><span class='match'>t<\/span><\/pre><\/li>\n  <li><pre><span class='match'>S<\/span><span class='match'>c<\/span><span class='match'>h<\/span><span class='match'>i<\/span>fff<span class='match'>a<\/span><span class='match'>h<\/span><span class='match'>r<\/span><span class='match'>t<\/span><\/pre><\/li>\n<\/ul>"},"evals":[],"jsHooks":[]}</script>

]

???

* `char_class()` hilft alle Symbole zu finden
* Mit `negated_char_class()` können alle Symbole "außer" die angebebenen identifiziert werden.
  * dies wird in rebus durch das Carat `^`-Symbol innerhalb der eckigen Klammer angezeigt

---
class: left

.blockquote[Wiederholungen]

## Zeichenketten mit mehreren gleichartigen Symbolen/Mustern

* Übersicht

| Muster               | Regelmäßiger Ausdruck |   rebus    |
|----------------------|:---------------------:|:----------:|
| Optional             |          `?`          |  `optional()` |
| Null oder mehr       |          `*`          |   `zero_or_more()` |
| Eins oder mehr     |          `+`          | `one_or_more()` |
| Zwischen m- und n-mal |    `{m,n}` | `repeated()`|

* Beispiel

```r
str_view(c("Frankfurt","Freiheit","Effekt","Schifffahrt"),
         pattern = repeated("Ff",2,3),html=TRUE
         )
```

<div class="str_view html-widget html-fill-item-overflow-hidden html-fill-item" id="htmlwidget-c4c980cfb6cc1b6afeb8" style="width:960px;height:100%;"></div>
<script type="application/json" data-for="htmlwidget-c4c980cfb6cc1b6afeb8">{"x":{"html":"<ul>\n  <li><pre>E<span class='match'>ff<\/span>ekt<\/pre><\/li>\n  <li><pre>Schi<span class='match'>fff<\/span>ahrt<\/pre><\/li>\n<\/ul>"},"evals":[],"jsHooks":[]}</script>

---
class: left

.blockquote[Abkürzungen]

## Abgekürzte Eingabe regelhafter Ausdrücke

.pull-left[

* $-Symbol und Ziffer(n):

```r
DOLLAR %R% char_class("0123456789")
```

```
## <regex> \$[0123456789]
```
]
--
.pull-right[
* Eine Ziffer:

```r
char_class("0-9")
```

```
## <regex> [0-9]
```

]
--

.pull-left[
* Kleinbuchstaben

```r
char_class("a-z")
```

```
## <regex> [a-z]
```

]
--
.pull-right[

* Großbuchstaben

```r
char_class("A-Z")
```

```
## <regex> [A-Z]
```

]

---
class: left

.blockquote[Abkürzungen]

## Abgekürzte Eingabe regelhafter Ausdrücke

.pull-left[

* Ziffern

```r
DGT
```

```
## <regex> \d
```

]
--

.pull-right[
<br>

```r
char_class("0-9")
```

```
## <regex> [0-9]
```
]
--
.pull-left[

* Buchstaben

```r
WRD
```

```
## <regex> \w
```
]
--
.pull-right[
<br>

```r
char_class("a-zA-Z0-0_")
```

```
## <regex> [a-zA-Z0-0_]
```
]
--
.pull-left[
* Leerzeichen (Whitespace)

```r
SPC
```

```
## <regex> \s
```

]

---
class: inverse, center, middle

## Fortgeschrittene regelhafte Ausdrücke

.blockquote[Erfassung (Capturing)]

.blockquote[Rückbezüge (Backreferences)]

.blockquote[Mustererkennung mit Unicode]

---
class: left

.blockquote[Erfassung (Capturing)]

##  Gruppierung von Teilmustern

* Dient der *Gruppierung von Teilen* von Mustern
* Erfasste Teile (von Mustern) können in darauffolgenden Schritten referenziert werden.

.pull-left[

```r
ANY_CHAR %R% "a"
```

```
## <regex> .a
```
]
--
.pull-right[

```r
str_extract(c("Fakten","Katzen"),
            pattern=ANY_CHAR %R% "a")
```

```
## [1] "Fa" "Ka"
```
]
--

.pull-left[

* Erfasste Teile (*captured groups*) werden in regulären Ausdrücken durch `()` angezeigt/eingegeben:

```r
capture(ANY_CHAR) %R% "a"
```

```
## <regex> (.)a
```
]
--
.pull-right[
* Capturing führt vordergründig (!) zum selben Ergebnis:

```r
str_extract(c("Fakten","Katzen"),
            capture(ANY_CHAR) %R% "a")
```

```
## [1] "Fa" "Ka"
```
]

???

* Capturing ändert nicht das Muster, das abgeglichen wird, entsprechend führt es auch zum selben Ergebnis
* Aber: capturing zeigt an, dass wir (in darauffolgenden Schritten) etwas mit dem erfassten Muster machen wollen

---
class: left

.blockquote[Erfassung (Capturing)]

##  Verwendung erfasster Teilmuster

* Verwendung in `str_match()` liefert eine Matrix, wobei die...
  * ...erste Spalte  dem Ergebnis von `str_extract()` entspricht.
  * ...zweite Spalte  nur den erfassten Teil des Musters enthält.

* Beispiel

```r
str_match(c("Fakten","Katze"), pattern=capture(ANY_CHAR) %R% "a")
```

```
##      [,1] [,2]
## [1,] "Fa" "F" 
## [2,] "Ka" "K"
```

???

* Verwendung in `str_match()` liefert eine Matrix
  * erste Spalte entspricht dem Ergebnis von `str_extract()` **mit dem exakten Match**
  * die zweite Spalte enthält dagegen nur den erfassten Teil des Musters in der captured group

---
class: left

.blockquote[Erfassung (Capturing)]

##  Anwendungsbeispiel mit erfassten Gruppen

* Beispiel: Dollar-Beträge unter 100$

```r
muster <- DOLLAR %R% DGT %R% optional(DGT) %R% DOT %R% dgt(2)
str_view(c("$7.70","$27.00"),pattern = muster)
```

```
## [1] │ <$7.70>
## [2] │ <$27.00>
```

* Nutzung erfasster Teilmuster zur getrennten Extraktion von Dollar- und Cent-Beträgen:

```r
cap_muster <- DOLLAR %R% capture(DGT %R% optional(DGT)) %R% DOT %R% capture(dgt(2))
str_match(c("$7.70","$27.00"), pattern = cap_muster)
```

```
##      [,1]     [,2] [,3]
## [1,] "$7.70"  "7"  "70"
## [2,] "$27.00" "27" "00"
```

???

* Obs! capture-Funktion wird zweimal verwendet:
  * einmal um die Vorkommastelle(n) und 
  * einmal um die Nachkommastellen

---
class: left

.blockquote[Rückbezüge (Backreferences)]

## Verweis auf erfasste Teile von Mustern

```r
REF1
```

```
## <regex> \1
```

```r
REF2
```

```
## <regex> \2
```

---
class: left

.blockquote[Mustererkennung mit Unicode]

## Unicode

---
class: inverse,center,middle

# Wir brauchen eine Pause.

---

background-image: url("data:image/png;base64,#http://bit.ly/cs631-donkey")
background-size: 80%

---
class: left

## Quellenverzeichnis

.ref-slide[
<a name=bib-wickham_r_2023></a>[Wickham, H., M. Çetinkaya-Rundel, and
G. Grolemund](#cite-wickham_r_2023) (2023). _R for Data Science:
Import, Tidy, Transform, Visualize, and Model Data_. 2nd Edition.
Beijing Boston Farnham Sebastopol Tokyo: O'Reilly. ISBN:
978-1-4920-9740-2.
]